﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Threading;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using PEMS.Common;

namespace PEMS.Server
{
    /// <summary>
    /// PemsService szervíz interfész, funkciók listája
    /// </summary>
    [ServiceContract(SessionMode = SessionMode.Required)]
    public interface IPemsService
    {
        /// <summary>
        /// authentikáció, fogad egy kliens leírót, megvizsgálja, beleír és visszaadja
        /// </summary>
        /// <param name="klid">fogad egy kliens leírót</param>
        /// <returns>visszaad egy kliens leírót</returns>
        [OperationContract(IsInitiating = true)]
        N_1 auth(N_1 komm);

        /// <summary>
        /// kliens leáll
        /// </summary>
        [OperationContract(IsTerminating = true, IsOneWay=true)]
        void stop();

        /// <summary>
        /// session fenntartása
        /// </summary>
        [OperationContract]
        void ping();

        /// <summary>
        /// a kliens lekérdezi a féléveket / összeset illetve csak azokat amikre jelentkezni lehet
        /// </summary>
        [OperationContract]
        N_1 getFelevList(N_1 komm);

        /// <summary>
        /// a kliens akarja látni egy félévhez meghirdetett kurzusokat
        /// </summary>
        [OperationContract]
        N_1 getKurzusList(N_1 komm);

        /// <summary>
        /// beiratkozás félévre
        /// </summary>
        [OperationContract]
        N_1 BeiratkozasFelevre(N_1 komm);

        /// <summary>
        /// lekérdezi a hallgató félév információit
        /// </summary>
        [OperationContract]
        N_1 getFelevInfo(N_1 komm);

        /// <summary>
        /// lekérdezi, hogy a hallgató beiratkozott-e a félévre
        /// </summary>
        [OperationContract]
        N_1 getFelevFelveve(N_1 komm);

        /// <summary>
        /// lekérdezi, hogy a hallgató felvette-e a kurzust
        /// </summary>
        [OperationContract]
        N_1 getKurzusFelveve(N_1 komm);

        /// <summary>
        /// lekérdezi, hogy a hallgató kapott-e aláírást
        /// </summary>
        [OperationContract]
        N_1 getAlairasBeallitva(N_1 komm);
                
        /// <summary>
        /// a kliens egy félév egy kurzusára feliratokozik
        /// </summary>
        [OperationContract]
        N_1 KurzusraFeliratkozik(N_1 komm);

        /// <summary>
        /// a kliens akarja látni egy félévhez egy kurzusának vizsgaidőpontjait
        /// </summary>
        [OperationContract]
        N_1 getKurzusVizsgaIdopontList(N_1 komm);

        /// <summary>
        /// vizsgajelentkezés
        /// </summary>
        [OperationContract]
        N_1 VizsgaIdopontraFeliratkozas(N_1 komm);

        /// <summary>
        /// vizsgajegy beírása
        /// </summary>
        [OperationContract]
        N_VizsgaJegyBeiras VizsgaJegyBeiras(N_VizsgaJegyBeiras komm);

        /// <summary>
        /// vizsgajegy ellenorzese
        /// </summary>
        [OperationContract]
        N_1 VizsgaJegyEllenorzes(N_1 komm);

        /// <summary>
        /// vizsgaeredmények lekérdezése
        /// </summary>
        [OperationContract]
        N_1 getVizsgaEredmenyek(N_1 komm);

        /// <summary>
        /// felvett kurzusok lekérdezése
        /// </summary>
        [OperationContract]
        N_1 getFelvettKurzus(N_1 komm);

        /// <summary>
        /// felvett kurzusok lekérdezése
        /// </summary>
        [OperationContract]
        N_1 getFelvettVizsga(N_1 komm);

        /// <summary>
        /// aláírás beállítása
        /// </summary>
        [OperationContract]
        N_AlairasBeallitas AlairasBeallitas(N_AlairasBeallitas komm);

    }

    /// <summary>
    /// a szolgáltatás megvalósítója, aki a implementál IPemsService interfészt
    /// ez szolgál kontrollerként
    /// </summary>
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    public class PemsService : IPemsService
    {
        string user=null;

        /// <summary>
        /// konstruktor
        /// </summary>
        public PemsService()
        {
            Log.logToFile("Szerviz objektum letrehozva (id):   " + this.GetHashCode().ToString(),false);
        }

        /// <summary>
        /// destruktor
        /// </summary>
        ~PemsService()
        {
            Log.logToFile("Szerviz objektum megsemmisitve (id): " + this.GetHashCode().ToString(),false);
            Intezmeny.instance.authenticated.Remove(this.GetHashCode().ToString());
        }

        /// <summary>
        /// kliens lelép
        /// </summary>
        public void stop(){}

        /// <summary>
        /// session fenntartása
        /// </summary>
        public void ping(){}

        /// <summary>
        /// egy felhasználó használhatja-e a rendszert?
        /// </summary>
        /// <param name="komm">őt vizsgáljuk</param>
        /// <returns>visszaadjuk azt amit ő küldött, plusz még beleteszünk infót</returns>
        public N_1 auth(N_1 komm)
        {
            komm.bools["belepve"] = false;
            komm.msg.Clear();

            lock (Intezmeny._lock)
            {
                foreach (KeyValuePair<string, Ember> e in Intezmeny.instance.emberList)
                {
                    if (e.Value.userName == komm.strings["userNev"] && e.Value.password == komm.strings["jelszo"] && e.Value.active)
                    {
                        OperationContext context = OperationContext.Current;

                        MessageProperties messageProperties = context.IncomingMessageProperties;
                        RemoteEndpointMessageProperty endpointProperty =
                            messageProperties[RemoteEndpointMessageProperty.Name]
                            as RemoteEndpointMessageProperty;
                        komm.strings["ip"] = endpointProperty.Address;

                        string clientinfo = string.Format("IP[{0}] port[{1}]", endpointProperty.Address, endpointProperty.Port);
                        Log.logToFile(clientinfo, false);
                        komm.strings["id"] = this.GetHashCode().ToString();
                        Log.logToFile(komm.strings["id"], false);

                        bool loggedon = false;
                        foreach (KeyValuePair<string, N_1> kvp in Intezmeny.instance.authenticated)
                        {
                            if (kvp.Value.strings["userNev"] == komm.strings["userNev"])
                                loggedon = true;
                        }
                        if (!loggedon)
                        {
                            komm.bools["belepve"] = true;
                            Intezmeny.instance.authenticated.Add(this.GetHashCode().ToString(), komm);
                            user = komm.strings["userNev"];
                            if (e.Value.GetType() == typeof(Hallgato))
                            {
                                komm.strings["jogosultsag"] = "Hallgato";
                            }
                            if (e.Value.GetType() == typeof(Tanar))
                            {
                                komm.strings["jogosultsag"] = "Oktato";
                            }
                            if (e.Value.GetType() == typeof(Admin))
                            {
                                komm.strings["jogosultsag"] = "Administrator";
                            }
                        }
                        else
                        {
                            komm.msg.Add("Ez a felhasznalo mar be van jelentkezve a szerverre!");
                            return komm;
                        }
                    }
                }
            }
            if (!komm.bools["belepve"])
                komm.msg.Add("\nFelhasznalo vagy jelszo nem megfelelo!");
            return komm;
        }

        /// <summary>
        /// a kliens lekérdezi a féléveket / összeset illetve csak azokat amikre jelentkezni lehet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a listázáshoz szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getFelevList(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                //végigmegyünk a féléveken
                foreach (KeyValuePair<string, Felev> f in Intezmeny.instance.felevList)
                {
                    List<string> row = new List<string>();
                    row.Add(f.Value.id);
                    row.Add(f.Value.megnevezes);
                    if (komm.bools["aktualis"])
                    {
                        if (f.Value.aktualis)
                        {
                            komm.rows.Add(row);
                        }
                    }
                    else
                    {
                        komm.rows.Add(row);
                    }
                }
            }
            return komm;
        }

        /// <summary>
        /// Felvehető kurzusokat akar látni a hallgató
        /// ehhez meg kell adni a félévet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a listázáshoz szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getKurzusList(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                //végigmegyünk a félév kurzusain
                foreach (KeyValuePair<string, Kurzus> kvp in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList)
                {
                    //és beletesszük a visszatérési objektumba
                    List<string> row = new List<string>();
                    row.Add(kvp.Value.id);
                    row.Add(kvp.Value.megnevezes);
                    komm.rows.Add(row);
                }
            }
            return komm;
        }

        /// <summary>
        /// Vizsgaidopontra akar jelentkezni a hallgató
        /// ehhez meg kell adni a félévet
        /// és a kurzusid-t
        /// és a vizsgaidopont ID-it
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a vizsga felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 VizsgaIdopontraFeliratkozas(N_1 komm)
        {
            lock (Intezmeny._lock)
            {    
                if(!Intezmeny.instance.felevList[komm.strings["felev"]].jelentkezettList.ContainsKey(user)){
                    komm.msg.Add("Felevtagsag kell a vizsgara jelentkezeshez!");                    
                    return komm;
                }
                if (!Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].kurzusTagList.ContainsKey(user))
                {
                    komm.msg.Add("Kurzustagsag kell a vizsgara jelentkezeshez!");
                    return komm;
                }
                //van-e aláírása a hallgatónak?
                bool vanAlairas = false;
                foreach (Alairas a in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].kurzusTagList[user].alairasok)
                {
                    if (a.alairas.Equals(AlairasEnum.alairva))
                    {
                        vanAlairas = true;
                    }
                }
                if (!vanAlairas)
                {
                    komm.msg.Add("A hallgatonak nincs alairasa, a vizsga nem veheto fel!");
                    return komm;
                }
                //van-e már van ilyen névvel jelentkezés?
                if (Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].vizsgaidopontList[komm.strings["vizsgaIdopontID"]].vizsgaList.ContainsKey(user))
                {
                    komm.msg.Add("Mar felvette a vizsgat!");
                    return komm;
                }

                try
                {
                    Vizsga v = Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].vizsgaidopontList[komm.strings["vizsgaIdopontID"]].vizsgaGyartas(Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].kurzusTagList[user]);
                    //és a vizsgát a kurzustag is nyilvántartja
                    Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].kurzusTagList[user].vizsgak.Add(v);
                    komm.msg.Add("Vizsga felveve erre az idopontra! " + Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].vizsgaidopontList[komm.strings["vizsgaIdopontID"]].idopont.ToString());
                }
                catch
                {
                    komm.msg.Add("Hiba a felvetelnel!");
                }
            }
            return komm;
        }

        /// <summary>
        /// beiratkozás félévre
        /// ehhez meg kell adni a félévet
        /// és a hallgatót
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 BeiratkozasFelevre(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                try
                {
                    Intezmeny.instance.felevList[komm.strings["felev"]].FelevJelentkezesgyartas(Intezmeny.instance.emberList[komm.strings["hallgato"]]);
                    komm.msg.Add("Beiratkozas a felevre megtortent!");
                }
                catch
                {
                    komm.msg.Add("Hiba a felevre torteno beiratkozas kozben!");
                }
            }
            return komm;
        }

        /// <summary>
        /// információ a hallgató által felvett félévekről
        /// ehhez meg kell adni a hallgatót
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getFelevInfo(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                try
                {
                    foreach (KeyValuePair<string, Felev> f in Intezmeny.instance.felevList)
                    {
                        List<string> row = new List<string>();
                        if (f.Value.jelentkezettList.ContainsKey(komm.strings["hallgato"]))
                        {
                            row.Add(f.Value.megnevezes);
                            row.Add("Meg nincs implementalva!");
                            komm.rows.Add(row);
                        }
                    }
                    if (komm.rows.Count == 0)
                    {
                        komm.msg.Add("Meg nem iratkozott be egyetlen felevre sem!");
                    }
                }
                catch
                {
                    komm.msg.Add("Hiba a feleves informaciok lekerdezese kozben!");
                }
            }            
            return komm;
        }

        /// <summary>
        /// lekérdezi, hogy a hallgató felvette-e a kérdéses félévet
        /// ehhez meg kell adni a hallgatót és a félévet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getFelevFelveve(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                try
                {
                    if (!Intezmeny.instance.felevList[komm.strings["felev"]].aktualis)
                    {
                        komm.msg.Add("A felevre nincs beiratkozasi idoszak!");
                        komm.bools["hiba"] = true;
                    }
                    if (!Intezmeny.instance.felevList.ContainsKey(komm.strings["felev"]))
                    {
                        komm.msg.Add("Nincs ilyen felev!");
                        komm.bools["hiba"] = true;
                    }
                    if (Intezmeny.instance.felevList[komm.strings["felev"]].jelentkezettList.ContainsKey(komm.strings["hallgato"]))
                    {
                        komm.bools["beiratkozott"] = true;
                        komm.msg.Add("A hallgato mar beiratkozott a felevre!");
                    }
                }
                catch
                {
                    komm.msg.Add("Hiba a felevtagsag lekerdezese kozben!");
                    komm.bools["hiba"] = true;
                }
            }
            return komm;
        }

        /// <summary>
        /// lekérdezi, hogy a hallgató felvette-e a kérdéses kurzust
        /// ehhez meg kell adni a hallgatót, a kurzust és a félévet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getKurzusFelveve(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                try
                {
                    if (!Intezmeny.instance.felevList[komm.strings["felev"]].jelentkezettList.ContainsKey(komm.strings["hallgato"]))
                    {
                        komm.msg.Add("Felevtagsag kell a kurzusra jelentkezeshez!");
                        komm.bools["hiba"] = true;
                    }
                    if (Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzus"]].kurzusTagList.ContainsKey(komm.strings["hallgato"]))
                    {
                        komm.msg.Add("Mar felvette a kurzust!");
                        komm.bools["hiba"] = true;
                    }
                    if (Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzus"]].kurzusTagList.ContainsKey(komm.strings["hallgato"]))
                    {
                        komm.bools["felvette"] = true;
                    }
                }
                catch
                {
                    komm.msg.Add("Hiba a kurzustagsag lekerdezese kozben!");
                    komm.bools["hiba"] = true;
                }
            }
            return komm;
        }

        /// <summary>
        /// lekérdezi, hogy a hallgató felvette-e a kérdéses félévet
        /// ehhez meg kell adni a hallgatót és a félévet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getAlairasBeallitva(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                if (!Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzus"]].kurzusTagList.ContainsKey(komm.strings["hallgato"]))
                {
                    komm.msg.Add("Hiba! A hallgatonak nincs ilyen kurzusa.");
                    komm.bools["hiba"] = true;
                }
                else
                {
                    try
                    {
                        foreach (Alairas a in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzus"]].kurzusTagList[komm.strings["hallgato"]].alairasok)
                        {
                            if (a.alairas.Equals(AlairasEnum.alairva))
                            {                                
                                komm.msg.Add("A hallgato mar kapott alairast!");
                                komm.bools["alairva"] = true;
                            }
                        }
                    }
                    catch
                    {
                        komm.msg.Add("Hiba az alairas lekerdezese kozben!");
                        komm.bools["hiba"] = true;
                    }
                }
            }
            return komm;
        }

        /// <summary>
        /// kurzusra akar feliratkozni a hallgató
        /// ehhez meg kell adni a félévet
        /// és a kurzusid-t
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a felvételhez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 KurzusraFeliratkozik(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                try
                {
                    komm.msg.Add(Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzusID"]].KurzusTagsaggyartas(Intezmeny.instance.felevList[komm.strings["felev"]].jelentkezettList[user]));
                }
                catch
                {
                    komm.msg.Add("Hiba a kurzus felvetelenel!");
                }
            }
            return komm;
        }

        public N_1 getKurzusVizsgaIdopontList(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                //végigmegyünk a félév kurzusának vizsgaidőpontjain
                foreach (KeyValuePair<string, VizsgaIdopont> kvp in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzus"]].vizsgaidopontList)
                {
                    //és beletesszük a visszatérési objektumba
                    List<string> row = new List<string>();
                    row.Add(kvp.Value.idopont.ToString());
                    row.Add(kvp.Value.maxLetszam.ToString());
                    komm.rows.Add(row);
                }
            }
            return komm;
        }
                

        /// <summary>
        /// Vizsgajegy beírása oktató által
        /// meg kell adni a félévet, kurzust, vizsgaidőpontot, hallgatót, érdemjegyet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a jegybeíráshoz szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 VizsgaJegyEllenorzes(N_1 komm)
        {
            lock (Intezmeny._lock)
            {   
                try
                {
                    // megvizsgáljuk jelentkezett-e a hallgató a vizsgára
                    if (!Intezmeny.instance.felevList[komm.strings["vfelev"]].kurzusList[komm.strings["vkurzus"]].vizsgaidopontList[komm.strings["vidopont"]].vizsgaList.ContainsKey(komm.strings["vhallgato"]))
                    {
                        komm.msg.Add("A hallgato nem jelentkezett vizsgara, nem lehet ertekelni!");
                        komm.bools["vizsgaJegyAdhato"] = false;
                    }
                    // ha már kapott jegyet a vizsgára, nem jelentkezhet ugyanarra az időpontra többet (ugyanis a vizsga már biztosan befejeződött)
                    else if (Intezmeny.instance.felevList[komm.strings["vfelev"]].kurzusList[komm.strings["vkurzus"]].vizsgaidopontList[komm.strings["vidopont"]].vizsgaList[komm.strings["vhallgato"]].erdemjegy != ErdemjegyEnum.meg_nem_vizsgazott)
                    {
                        komm.msg.Add("A vizsga mar elozoleg ertekelve lett, nem tortent modositas!");
                        komm.bools["vizsgaJegyAdhato"] = false;
                    }
                }
                catch
                {
                    komm.msg.Add("Hiba a vizsgajegy ellenorzese kozben!");
                    komm.bools["vizsgaJegyAdhato"] = false;
                }
            }            
            return komm;
        }

        /// <summary>
        /// Vizsgajegy beírása oktató által
        /// meg kell adni a félévet, kurzust, vizsgaidőpontot, hallgatót, érdemjegyet
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a jegybeíráshoz szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_VizsgaJegyBeiras VizsgaJegyBeiras(N_VizsgaJegyBeiras komm)
        {
            lock (Intezmeny._lock)
            {                
                try
                {
                    Intezmeny.instance.felevList[komm.strings["vfelev"]].kurzusList[komm.strings["vkurzus"]].vizsgaidopontList[komm.strings["vidopont"]].vizsgaList[komm.strings["vhallgato"]].erdemjegy = (ErdemjegyEnum)komm.vjegy;
                    komm.msg.Add("Vizsgaertelekes leadva! A beirt jegy: " + Intezmeny.instance.felevList[komm.strings["vfelev"]].kurzusList[komm.strings["vkurzus"]].vizsgaidopontList[komm.strings["vidopont"]].vizsgaList[komm.strings["vhallgato"]].erdemjegy.ToString());
                }
                catch
                {
                    komm.msg.Add("Hiba a vizsgajegy beirasa kozben!");
                }
            }
            return komm;
        }

        /// <summary>
        /// Felvett kurzusok lekérdezése
        /// meg kell adni a félévet és a hallgatót
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a lekérdezéshez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getFelvettKurzus(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                komm.msg.Add("Meg nem vett fel kurzust a kerdeses felevben.");
                foreach (KeyValuePair<string, Kurzus> k in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList)
                    foreach (KeyValuePair<string, KurzusTagsag> kt in k.Value.kurzusTagList)
                        if (kt.Value.felevJelentkezes.hallgato.userName.Equals(komm.strings["hallgato"]))
                        {
                            komm.msg.Clear();
                            List<string> row = new List<string>();                            
                            try
                            {
                                row.Add(k.Value.targy.megnevezes.ToString());
                                row.Add(k.Value.targy.felvetelekSzama[komm.strings["hallgato"]].ToString());
                            }
                            catch 
                            {
                                komm.msg.Add("Hiba a felvett kurzusok lekerdezese kozben!");
                            }
                            komm.rows.Add(row);
                        }
            }
            return komm;
        }

        /// <summary>
        /// Felvett vizsgák lekérdezése
        /// meg kell adni a félévet és a hallgatót
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a lekérdezéshez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getFelvettVizsga(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                foreach (KeyValuePair<string, Kurzus> k in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList)
                    foreach (KeyValuePair<string, VizsgaIdopont> v in k.Value.vizsgaidopontList)
                        if (v.Value.vizsgaList.ContainsKey(komm.strings["hallgato"]))
                        {
                            List<string> row = new List<string>();
                            row.Add(k.Value.targy.megnevezes.ToString());
                            row.Add(v.Value.idopont.ToString());
                            komm.rows.Add(row);
                            
                        }
                        else
                        {
                            komm.msg.Add("Meg nem vett fel vizsgat a kerdeses felevben.");
                        }
            }
            return komm;
        }

        /// <summary>
        /// Vizsgaeredmények lekérdezése
        /// meg kell adni a félévet és a hallgatót
        /// </summary>
        /// <param name="komm">ebben kapjuk meg a lekérdezéshez szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_1 getVizsgaEredmenyek(N_1 komm)
        {
            lock (Intezmeny._lock)
            {
                foreach (KeyValuePair<string, Kurzus> k in Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList)
                    foreach (KeyValuePair<string,VizsgaIdopont> v in k.Value.vizsgaidopontList)
                        if (v.Value.vizsgaList.ContainsKey(komm.strings["hallgato"]))
                        {
                            List<string> row = new List<string>();
                            row.Add(k.Value.targy.megnevezes.ToString());
                            if (v.Value.vizsgaList[komm.strings["hallgato"]].erdemjegy != ErdemjegyEnum.meg_nem_vizsgazott)
                            {
                                row.Add(v.Value.vizsgaList[komm.strings["hallgato"]].erdemjegy.ToString());
                            }
                            else
                            {
                                row.Add("Meg nincs ertekelve a vizsga.");
                            }
                            komm.rows.Add(row);
                        }
                        else
                        {
                            komm.msg.Add("Meg nem vett fel vizsgat a kerdeses felevben.");
                        }
            }
            return komm;
        }

        /// <summary>
        /// Aláírás beállítása oktató által
        /// meg kell adni a félévet, kurzust, hallgatót
        /// </summary>
        /// <param name="komm">ebben kapjuk meg az aláírásbeállításhoz szükséges infokat</param>
        /// <returns>visszaadjuk azt amit ő küldött, és beletesszük a visszatérési infot</returns>
        public N_AlairasBeallitas AlairasBeallitas(N_AlairasBeallitas komm)
        {
            lock (Intezmeny._lock)
            {
                try
                {
                    Intezmeny.instance.felevList[komm.strings["felev"]].kurzusList[komm.strings["kurzus"]].kurzusTagList[komm.strings["hallgato"]].Alairasgyartas(komm.alairasErtek);
                    komm.msg.Add("Alairas beallitva.");
                }
                catch
                {
                    komm.msg.Add("Hiba az alairas beallitasa beirasa kozben!");
                }
            }
            return komm;
        }

    }
}
